import storage from './storage'
/** niushop 的代码 暂时这么写 */
/**
 * 生成唯一字符
 * @param {Number} len
 * @param {Boolean} firstU
 * @param {Number} radix
 */
export function guid(len = 10, firstU = true, radix: any = null) {
  const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
  const uuid = []
  radix = radix || chars.length

  if (len) {
    // 如果指定uuid长度,只是取随机的字符,0|x为位运算,能去掉x的小数位,返回整数位
    for (let i = 0; i < len; i++) uuid[i] = chars[0 | (Math.random() * radix)]
  } else {
    let r
    // rfc4122标准要求返回的uuid中,某些位为固定的字符
    uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-'
    uuid[14] = '4'

    for (let i = 0; i < 36; i++) {
      if (!uuid[i]) {
        r = 0 | (Math.random() * 16)
        uuid[i] = chars[i == 19 ? (r & 0x3) | 0x8 : r]
      }
    }
  }
  // 移除第一个字符,并用u替代,因为第一个字符为数值时,该guuid不能用作id或者class
  if (firstU) {
    uuid.shift()
    return `u${uuid.join('')}`
  }
  return uuid.join('')
}
/**
 * 过滤小数点(保留两位)
 * @param event
 */
export function filterDigit(event: any) {
  event.target.value = event.target.value.replace(/[^\d\.]/g, '')
  event.target.value = event.target.value.replace(/^\./g, '')
  event.target.value = event.target.value.replace(/\.{2,}/g, '.')
  // 限制最多两位小数
  const decimalParts = event.target.value.split('.')
  if (decimalParts.length > 1 && decimalParts[1].length > 2) {
    // 如果有小数部分且超过两位，则截取前两位
    event.target.value = `${decimalParts[0]}.${decimalParts[1].slice(0, 2)}`
  }
}
/**
 * 过滤整数
 * @param event
 */
export function filterNumber(event: any) {
  event.target.value = event.target.value.replace(/[^\d]/g, '')
}
/**
 * 防抖函数
 * @param fn
 * @param delay
 * @returns
 */
export function debounce(fn: (args?: any) => any, delay: number = 300) {
  let timer: null | number = null
  return function (...args) {
    if (timer != null) {
      clearTimeout(timer)
      timer = null
    }
    timer = setTimeout(() => {
      fn.call(this, ...args)
    }, delay)
  }
}
/**
 * 判断是否是url
 * @param str
 * @returns
 */
export function isUrl(str: string): boolean {
  return str.indexOf('http://') != -1 || str.indexOf('https://') != -1
}

/**
 * 图片输出
 * @param path
 * @returns
 */
export function img(path: string): string {
  if (isUrl(path)) {
    return path
  } else {
    let baseURL = import.meta.env.VITE_IMG_DOMAIN || location.origin
    baseURL = baseURL.substr(-1) == '/' ? baseURL : `${baseURL}/`
    if (path.substr(0, 1) == '/') path = path.substr(1)
    return baseURL + path
  }
}
/**
 * 获取当前访问应用类型
 */
export function getAppType() {
  const path = location.pathname.split('/').filter((val) => {
    return val
  })

  if (!path.length) {
    return 'admin'
  } else {
    return path[0]
  }
}
/**
 * 获取token
 * @returns
 */
export function getToken(): null | string {
  return storage.get('token')
}

/**
 * 设置token
 * @param token
 * @returns
 */
export function setToken(token: string): void {
  storage.set({ key: 'token', data: token })
}

/**
 * 移除token
 * @returns
 */
export function removeToken(): void {
  storage.remove('token')
}
const isArray = (value: any) => {
  if (typeof Array.isArray === 'function') {
    return Array.isArray(value)
  }
  return Object.prototype.toString.call(value) === '[object Array]'
}

/**
 * @description 深度克隆
 * @param {object} obj 需要深度克隆的对象
 * @returns {*} 克隆后的对象或者原值（不是对象）
 */
export function deepClone(obj: object) {
  // 对常见的“非”值，直接返回原来值
  if ([null, undefined, NaN, false].includes(obj)) return obj
  if (typeof obj !== 'object' && typeof obj !== 'function') {
    // 原始类型直接返回
    return obj
  }
  const o = isArray(obj) ? [] : {}
  for (const i in obj) {
    if (obj.hasOwnProperty(i)) {
      o[i] = typeof obj[i] === 'object' ? deepClone(obj[i]) : obj[i]
    }
  }
  return o
}
/**
 * 设置表格分页数据的本地存储
 * @param page
 * @param limit
 * @param where
 */
export function setTablePageStorage(page: any = 1, limit: any = 10, where: any = {}) {
  let data = storage.get('tablePageStorage')
  if (!data) {
    data = {}
  }

  let key = location.pathname + JSON.stringify(where)
  data[key] = {
    page,
    limit
  }

  let MAX_COUNT = 5 // 最多存储 5 个页面的分页缓存，超出则删除最开始的第一个页面
  if (Object.keys(data).length > MAX_COUNT) {
    delete data[Object.keys(data)[0]]
  }

  storage.set({ key: 'tablePageStorage', data })
}

/**
 * 获取表格分页数据的本地存储
 * @param where
 */
export function getTablePageStorage(where: any = {}) {
  let data = storage.get('tablePageStorage')
  let key = location.pathname + JSON.stringify(where)
  if (!data || !data[key]) {
    data = {
      page: 1,
      limit: 10
    }
  } else {
    data = data[key]
  }
  return data
}

/**
 * 获取字符串字节长度
 * @param str
 * @returns
 */
export function strByteLength(str: string = ''): number {
  let len = 0
  for (let i = 0; i < str.length; i++) {
    if (str.charCodeAt(i) > 127 || str.charCodeAt(i) == 94) {
      len += 2
    } else {
      len++
    }
  }
  return len
}
